home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / CUGUK / APPLICAT / C034.ZIP / DBQSEL2.C < prev    next >
Text File  |  2010-11-01  |  6KB  |  313 lines
  1. /* SDB - select items from database - part 2 */
  2.  
  3. #include "bdscio.h"
  4. #include "dbqdefs.h"
  5.  
  6. get_srels(slptr)
  7.     struct sel *slptr;
  8. {
  9.     char rname[KEYWORDMAX+1],*aname;
  10.  
  11.     while (TRUE) {
  12.  
  13.         if (db_ntoken() != ID)
  14.             { RETERR(SYNTAX) }
  15.         strcpy(rname,dbv_tstring);
  16.  
  17.         if (db_token() == ID) {
  18.             db_ntoken();
  19.             aname = dbv_tstring;
  20.         }
  21.         else
  22.             aname = NULL;
  23.  
  24.         if (!srelation(slptr,rname,aname))
  25.             return (FALSE);
  26.  
  27.         if (db_token() != ',')
  28.             break;
  29.         db_ntoken();
  30.     }
  31.  
  32.     return (TRUE);
  33. }
  34.  
  35. srelation(slptr,rname,aname)
  36.     struct sel *slptr; char *rname,*aname;
  37. {
  38.     struct srel *srptr,*newsrel;
  39.  
  40.     if ((newsrel = CALLOC(SRELSIZE)) == NULL)
  41.         { RETERR(INSMEM) }
  42.  
  43.     newsrel->sr_ctuple = FALSE;
  44.     newsrel->sr_update = FALSE;
  45.     newsrel->sr_next = NULL;
  46.  
  47.     if ((newsrel->sr_scan = db_ropen(rname)) == NULL) {
  48.         CFREE(newsrel);
  49.         return (FALSE);
  50.     }
  51.  
  52.     if (aname != NULL) {
  53.         if ((newsrel->sr_name = CALLOC(strlen(aname)+1)) == NULL) {
  54.             CFREE(newsrel);
  55.             RETERR(INSMEM)
  56.         }
  57.         strcpy(newsrel->sr_name,aname);
  58.     }
  59.     else
  60.         newsrel->sr_name = NULL;
  61.  
  62.     for (srptr = slptr->sl_rels; srptr != NULL; srptr = srptr->sr_next)
  63.         if (srptr->sr_next == NULL)
  64.             break;
  65.  
  66.     if (srptr == NULL)
  67.         slptr->sl_rels = newsrel;
  68.     else
  69.         srptr->sr_next = newsrel;
  70.  
  71.     return (TRUE);
  72. }
  73.  
  74. int check_attrs(slptr)
  75.     struct sel *slptr;
  76. {
  77.     struct sattr *saptr;
  78.  
  79.     if (slptr->sl_rels == NULL)
  80.         { RETERR(RELFNF) }
  81.  
  82.     if (slptr->sl_attrs == NULL)
  83.         return (all_attrs(slptr));
  84.  
  85.     for (saptr = slptr->sl_attrs; saptr != NULL; saptr = saptr->sa_next)
  86.         if (!find_attr(slptr,saptr->sa_rname,saptr->sa_aname,
  87.             &saptr->sa_aptr,&saptr->sa_srel,&saptr->sa_attr))
  88.         return (FALSE);
  89.  
  90.     return (TRUE);
  91. }
  92.  
  93.  
  94. int all_attrs(slptr)
  95.     struct sel *slptr;
  96. {
  97.     struct sattr *newsattr,*lastsattr;
  98.     struct srel *srptr;
  99.     struct attribute *aptr;
  100.     int i,astart;
  101.  
  102.     lastsattr = NULL;
  103.     for (srptr = slptr->sl_rels; srptr != NULL; srptr = srptr->sr_next) {
  104.  
  105.         astart = 1;
  106.         for (i = 0; i < NATTRS; i++) {
  107.  
  108.             aptr = &srptr->sr_scan->sc_relation->rl_header.hd_attrs[i];
  109.             if (aptr->at_name[0] == 0)
  110.             break;
  111.             if ((newsattr = CALLOC(SATSIZE)) == NULL)
  112.                 { RETERR(INSMEM) }
  113.             newsattr->sa_name = NULL;
  114.             newsattr->sa_total = NULL;
  115.             newsattr->sa_srel = srptr;
  116.             newsattr->sa_aptr = srptr->sr_scan->sc_tuple + astart;
  117.             newsattr->sa_attr = aptr;
  118.             newsattr->sa_next = NULL;
  119.  
  120.             if ((newsattr->sa_rname = CALLOC(RNSIZE+1)) == NULL) {
  121.                 CFREE(newsattr);
  122.                 RETERR(INSMEM)
  123.             }
  124.             strncpy(newsattr->sa_rname,
  125.                 srptr->sr_scan->sc_relation->rl_name,RNSIZE);
  126.             newsattr->sa_rname[RNSIZE] = 0;
  127.  
  128.             if (dbv_total && (aptr->at_type == TNUM)) {
  129.                 if ((newsattr->sa_total = CALLOC(4)) == NULL) {
  130.                     if (newsattr->sa_rname != NULL)
  131.                         CFREE(newsattr->sa_rname);
  132.                     CFREE(newsattr);
  133.                     RETERR(INSMEM)
  134.                 }    
  135.                 setmem(newsattr->sa_total,4,NULL);
  136.             } else
  137.                 newsattr->sa_total = NULL;
  138.     
  139.         
  140.             if ((newsattr->sa_aname = CALLOC(ANSIZE+1)) == NULL) {
  141.                 CFREE(newsattr->sa_rname);
  142.                 CFREE(newsattr);
  143.                 RETERR(INSMEM)
  144.             }
  145.  
  146.             strncpy(newsattr->sa_aname,
  147.         srptr->sr_scan->sc_relation->rl_header.hd_attrs[i].at_name,
  148.                 ANSIZE);
  149.             newsattr->sa_aname[ANSIZE] = 0;
  150.  
  151.             if (lastsattr == NULL)
  152.                 slptr->sl_attrs = newsattr;
  153.             else
  154.                 lastsattr->sa_next = newsattr;
  155.             lastsattr = newsattr;
  156.  
  157.             astart += aptr->at_size;
  158.         }
  159.     }
  160.  
  161.     return (TRUE);
  162. }
  163.  
  164. int find_attr(slptr,rname,aname,paptr,psrel,pattr)
  165.     struct sel *slptr; char *rname,*aname;
  166.     char **paptr; struct attribute **pattr;
  167. {
  168.     if (rname == NULL)
  169.         return (uattr(slptr,aname,paptr,psrel,pattr));
  170.     else
  171.         return (qattr(slptr,rname,aname,paptr,psrel,pattr));
  172. }
  173.  
  174. int uattr(slptr,aname,paptr,psrel,pattr)
  175.     struct sel *slptr; char *aname;
  176.     char **paptr; struct srel **psrel; struct attribute **pattr;
  177. {
  178.     struct srel *srptr;
  179.     struct attribute *aptr;
  180.     int i,astart;
  181.  
  182.     *pattr = NULL;
  183.     for (srptr = slptr->sl_rels; srptr != NULL; srptr = srptr->sr_next) {
  184.  
  185.         astart = 1;
  186.         for (i = 0; i < NATTRS; i++) {
  187.  
  188.         aptr = &srptr->sr_scan->sc_relation->rl_header.hd_attrs[i];
  189.         if (aptr->at_name[0] == 0)
  190.             break;
  191.  
  192.         if (db_sncmp(aname,aptr->at_name,ANSIZE) == 0) {
  193.             if (*pattr != NULL)
  194.                 { RETERR(ATAMBG) }
  195.             *paptr = srptr->sr_scan->sc_tuple + astart;
  196.             *psrel = srptr;
  197.             *pattr = aptr;
  198.         }
  199.  
  200.         astart += aptr->at_size;
  201.         }
  202.     }
  203.  
  204.     if (*pattr == NULL)
  205.         { RETERR(ATUNDF) }
  206.  
  207.     return (TRUE);
  208. }
  209.  
  210.  
  211. int qattr(slptr,rname,aname,paptr,psrel,pattr)
  212.     struct sel *slptr; char *rname,*aname;
  213.     char **paptr; struct srel **psrel; struct attribute **pattr;
  214. {
  215.     struct srel *srptr;
  216.     struct attribute *aptr;
  217.     char *crname;
  218.     int i,astart;
  219.  
  220.     *pattr = NULL;
  221.     for (srptr = slptr->sl_rels; srptr != NULL; srptr = srptr->sr_next) {
  222.  
  223.         if ((crname = srptr->sr_name) == NULL)
  224.             crname = srptr->sr_scan->sc_relation->rl_name;
  225.  
  226.         if (db_sncmp(rname,crname,RNSIZE) == 0) {
  227.  
  228.             astart = 1;
  229.             for (i = 0; i < NATTRS; i++) {
  230.  
  231.         aptr = &srptr->sr_scan->sc_relation->rl_header.hd_attrs[i];
  232.         if (aptr->at_name[0] == 0)
  233.             break;
  234.  
  235.         if (db_sncmp(aname,aptr->at_name,ANSIZE) == 0) {
  236.             *paptr = srptr->sr_scan->sc_tuple + astart;
  237.             *psrel = srptr;
  238.             *pattr = aptr;
  239.             return (TRUE);
  240.         }
  241.  
  242.         astart += aptr->at_size;
  243.         }
  244.  
  245.         RETERR(ATUNDF)
  246.         }
  247.     }
  248.  
  249.  
  250.     RETERR(RLUNDF)
  251. }
  252.  
  253.  
  254. int process(srptr)
  255.     struct srel *srptr;
  256. {
  257.  
  258.     if (srptr->sr_next == NULL) {
  259.  
  260.         if (!srptr->sr_ctuple)
  261.             db_rbegin(srptr->sr_scan);
  262.  
  263.         return (srptr->sr_ctuple = db_rfetch(srptr->sr_scan));
  264.     }
  265.  
  266.     if (!srptr->sr_ctuple) {
  267.         db_rbegin(srptr->sr_scan);
  268.  
  269.         if (!db_rfetch(srptr->sr_scan))
  270.             return (FALSE);
  271.     }
  272.  
  273.     while (!process(srptr->sr_next))
  274.  
  275.         if (!db_rfetch(srptr->sr_scan))
  276.             return (srptr->sr_ctuple = FALSE);
  277.  
  278.     return (srptr->sr_ctuple = TRUE);
  279. }
  280.  
  281. db_aget(aptr,vptr,avalue)
  282.     struct attribute *aptr; char *vptr,*avalue;
  283. {
  284.     int i;
  285.  
  286.     for (i = 0;i < aptr->at_size; i++)
  287.         *avalue++ = vptr[i];
  288.     *avalue = EOS;
  289. }
  290.  
  291. db_aput(aptr,vptr,avalue)
  292.     struct attribute *aptr; char *vptr,*avalue;
  293. {
  294.     int i;
  295.  
  296.     i = 0;
  297.  
  298.     if (aptr->at_type == TNUM)
  299.         for (; i < aptr->at_size - strlen(avalue); i++)
  300.             vptr[i] = ' ';
  301.  
  302.     for (; i < aptr->at_size; i++)
  303.         if (*avalue == 0)
  304.             vptr[i] = 0;
  305.         else
  306.             vptr[i] = *avalue++;
  307. }
  308.  
  309. vptr[i] = ' ';
  310.  
  311.     for (; i < aptr->at_size; i++)
  312.         if (*avalue == 0)
  313.             vptr[i